//给你一个下标从 0 开始的字符串数组 words ，和一个下标从 0 开始的 二进制 数组 groups ，两个数组长度都是 n 。 
//
// 你需要从 words 中选出 最长子序列。如果对于序列中的任何两个连续串，二进制数组 groups 中它们的对应元素不同，则 words 的子序列是不同的
//。 
//
// 正式来说，你需要从下标 [0, 1, ..., n - 1] 中选出一个 最长子序列 ，将这个子序列记作长度为 k 的 [i0, i1, ..., ik 
//- 1] ，对于所有满足 0 <= j < k - 1 的 j 都有 groups[ij] != groups[ij + 1] 。 
//
// 请你返回一个字符串数组，它是下标子序列 依次 对应 words 数组中的字符串连接形成的字符串数组。如果有多个答案，返回 任意 一个。 
//
// 注意：words 中的元素是不同的 。 
//
// 
//
// 示例 1： 
//
// 
//输入：words = ["e","a","b"], groups = [0,0,1]
//输出：["e","b"]
//解释：一个可行的子序列是 [0,2] ，因为 groups[0] != groups[2] 。
//所以一个可行的答案是 [words[0],words[2]] = ["e","b"] 。
//另一个可行的子序列是 [1,2] ，因为 groups[1] != groups[2] 。
//得到答案为 [words[1],words[2]] = ["a","b"] 。
//这也是一个可行的答案。
//符合题意的最长子序列的长度为 2 。 
//
// 示例 2： 
//
// 
//输入：words = ["a","b","c","d"], groups = [1,0,1,1]
//输出：["a","b","c"]
//解释：一个可行的子序列为 [0,1,2] 因为 groups[0] != groups[1] 且 groups[1] != groups[2] 。
//所以一个可行的答案是 [words[0],words[1],words[2]] = ["a","b","c"] 。
//另一个可行的子序列为 [0,1,3] 因为 groups[0] != groups[1] 且 groups[1] != groups[3] 。
//得到答案为 [words[0],words[1],words[3]] = ["a","b","d"] 。
//这也是一个可行的答案。
//符合题意的最长子序列的长度为 3 。 
//
// 
//
// 提示： 
//
// 
// 1 <= n == words.length == groups.length <= 100 
// 1 <= words[i].length <= 10 
// groups[i] 是 0 或 1。 
// words 中的字符串 互不相同 。 
// words[i] 只包含小写英文字母。 
// 
//
// Related Topics 贪心 数组 字符串 动态规划 👍 12 👎 0


package LeetCode.editor.cn;


import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @author ldltd
 * @date 2025-05-15 09:30:22
 * @description 2900.最长相邻不相等子序列 I
 
 */
 
public class LongestUnequalAdjacentGroupsSubsequenceI {
    public static void main(String[] args) {
    //测试代码
    LongestUnequalAdjacentGroupsSubsequenceI fun = new LongestUnequalAdjacentGroupsSubsequenceI();
    Solution solution= fun.new Solution();
    solution.getLongestSubsequence(new String[]{"d","g"},new int[]{0,1});
    }

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    public List<String> getLongestSubsequence1(String[] words, int[] groups) {
        List<String>res0=new ArrayList<>();
        List<String> res1=new ArrayList<>();
        int flag1=1;
        int flag0=0;
        for (int i = 0; i < groups.length; i++) {
            if(groups[i]==flag1){
                res1.add(words[i]);
                flag1=1^flag1;
            }
            if (groups[i]==flag0){
                res0.add(words[i]);
                flag0=1^flag0;
            }
        }
        return res1.size()>res0.size()?res1:res0;
    }
    //贪心
    public List<String> getLongestSubsequence2(String[] words, int[] groups) {
        List<String> ans = new ArrayList<>();
        int n = words.length;
        for (int i = 0; i < n; i++) {
            if (i == 0 || groups[i] != groups[i - 1]) {
                ans.add(words[i]);
            }
        }
        return ans;
    }
    //动态规划
    public List<String> getLongestSubsequence(String[] words, int[] groups) {
        int n = words.length;
        //dp[i]表示以i结尾的最长子序列长度，i之前的元素为j，
        //此时groups[i]!=group[j],j<i，
        //dp[i]=Max(dp[i],dp[j]+1) if(groups[i]!=groups[j])
        //pre[i]记录最长子序列中索引i的前一个元素j，
        //当找到最长子序列时，pre[i]可以用来回溯，来找到答案
        int[] dp = new int[n];
        int[] prev = new int[n];
        //maxLen表示最长子序列的长度，endIndex表示最长子序列的最后一个元素的索引
        int maxLen = 1, endIndex = 0;
        //初始化dp和prev数组
        for (int i = 0; i < n; i++) {
            dp[i] = 1;
            prev[i] = -1;
        }
        for (int i = 1; i < n; i++) {
            int bestLen = 1;
            int bestPrev = -1;
            for (int j = i - 1; j >= 0; j--) {
                if (groups[i] != groups[j] && dp[j] + 1 > bestLen) {
                    bestLen = dp[j] + 1;
                    bestPrev = j;
                }
            }
            dp[i] = bestLen;
            prev[i] = bestPrev;
            if (dp[i] > maxLen) {
                maxLen = dp[i];
                endIndex = i;
            }
        }

        List<String> res = new ArrayList<>();
        for (int i = endIndex; i != -1; i = prev[i]) {
            res.add(words[i]);
        }
        Collections.reverse(res);
        return res;
    }

}
//leetcode submit region end(Prohibit modification and deletion)

}
